Developer CD Series 1992 June: ROMin Holiday

home *** CD-ROM | disk | FTP | other *** search

/ Developer CD Series 1992 June: ROMin Holiday / ADC Developer CD (1992-06) (''ROMin Holiday'')_iso / Developer Connection - 06-1992.iso / Development Platforms / Apple II / Apple II Sample Code / APW.SC / SC05Cust.Wind / RR.Wnd.asm2 < prev next >

Wrap

Text File | 1990-05-17 | 41.6 KB | 1,196 lines | [TEXT/pdos]

EJECT ******************************************************************************* * rrHit start * * Description: Test to see which part of the window was hit (if any). * * * Inputs: param = point to test * bits 0-15 = Y-coord; * bits 16-31 = X-coord. * (in local coordinates) * * Outputs: result = 0 wNoHit Not on the window at all * 20 wInDrag in Drag bar region * *21 wInGrow in Grow region * 22 wInGoAway in Go-away region * *23 wInZoom in Zoom region * *24 wInInfo in Info bar * 27 wInFrame in the window, but none of above * carry = clear * (Result numbers with an asterisk (*) next to them are * not supported in this window) * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData lda <param ; Make a copy of this so that it will sta myLocalPoint ; be easier push its address onto the lda <param+2 ; stack. sta myLocalPoint+2 PushLong #myLocalPoint _LocalToGlobal ; Check to see if the mouse was clicked in the strucRgn, which is also ; in global coordinates. pha ; room for result PushLong #myLocalPoint ; push a pointer to the point ldy #owStrucRgn+2 ; push on strucRgn from theWindow lda [<theWindow],y pha dey dey lda [<theWindow],y pha _PtInRgn pla ; did we hit the strucRgn? beq done ; no, return no hit jsr ckGoAway ; did we hit the goaway box? bne done ; if so, it returns wInGoAway ldy #owFrame ; is the window draggable? lda [<theWindow],y and #fMove beq notDraggable ; no, return wInFrame part lda <param ; load in the Y coordinate ldy #titleHeight cmp [<windGlobals],y ; is it in the title region bge notDraggable ; no, so return wInFrame. lda #wInDrag ; return wInDrag bra done notDraggable ANOP lda #wInFrame ; fall to exit routine done ANOP sta <result clc rts ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ckGoAway ANOP ; ; See if the mouse button was clicked while the cursor was in the ; goaway box. We simply use PtInRect for this. ; ; The window must both be active and have a close box in order for ; us to return a 'wInGoAway' condition. ; ldy #owFrame ; Check for these conditions in lda [<theWindow],y ; one blow. If both bits are set, and #fHilited+fClose ; then check to see if we landed in cmp #fHilited+fClose ; the close box. If both are not bne notInGoAway ; set, then leave. ldy #closeHeight ; calculate the dimensions of the lda [<windGlobals],y ; goAway box. clc adc goAwayRect sta goAwayRect+4 ldy #closeWidth lda [<windGlobals],y clc adc goAwayRect+2 sta goAwayRect+6 lda <param ; we need this back in global sta myLocalPoint ; coordinates lda <param+2 sta myLocalPoint+2 pha ; room for result PushLong #myLocalPoint ; check the mouse click PushLong #goAwayRect _PtInRect pla beq notInGoAway ; not there, return zero lda #wInGoAway ; hit close box, return wInGoAway bra doneGoAway notInGoAway ANOP lda #wNoHit doneGoAway ANOP rts myLocalPoint ds 4 goAwayRect dc i2'GAY,GAX,0,0' end EJECT ******************************************************************************* * rrCalcRgns start * * Description: Calculate the content and structure regions of the window * in Global coordinates. * * * Inputs: theWindow's portRect and boundsRect will be set * appropriately. NOTE: The strucRgn and contRgn must be * returned in GLOBAL coordinates. However, while the * settings of the portRect and boundsRect show the relative * positioning of the window on the desktop, they do not give * a rectangle in global coordinates on which we can base our * calculations. The routine "GetpRect" shows the correct way * to get a rectangle in global coordinates on which you * should base your calculations. * * Outputs: result = 0 * carry = clear * theWindow.StrucRgn = frame region * (region handle already allocated) * theWindow.ContRgn = content region * (region handle already allocated) * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData jsr GetpRect ; get portRect; convert to Globals ; ; Create the rectangle we will use for creating the strucRgn. This is ; calculated based on the portRect, titleHeight, and screen mode. ; ldy #titleHeight ; Get the suggested height of titlebar lda contRect ; Raise the height of the strucRect by sec ; that much. sbc [<windGlobals],y sta strucRect lda contRect+4 ; lower bottom of the strucRect by 1 ina sta strucRect+4 ldy #lineW ; adjust width of the strucRect based lda contRect+2 ; on the size of the lineWidth sec sbc [<windGlobals],y ; one linewidth on the left... sta strucRect+2 lda contRect+6 clc adc [<windGlobals],y ; ...and on the right. sta strucRect+6 ; now create the Content Region by doing a FrameRRect on the contRect, and ; adding a square region to it. First create a round rect region of the full ; content size. _OpenRgn PushLong #contRect ldy #xowRH ; these are the radii of the corners PushWord [<theWindow],y ldy #xowRV PushWord [<theWindow],y _FrameRRect ldy #owContRgn+2 ; push on the handle of the content lda [<theWindow],y ; region stored in the window record sta ContRgnHandle+2 pha dey dey lda [<theWindow],y sta ContRgnHandle pha _CloseRgn ; Now create a square region to fill in the small upper corners. pha pha _NewRgn PullLong TempRgn lda contRect clc ldy #xowRV adc [<theWindow],y sta contRect+4 PushLong TempRgn PushLong #contRect _RectRgn ; Add the two regions together. PushLong ContRgnHandle PushLong TempRgn PushLong ContRgnHandle _UnionRgn PushLong TempRgn _DisposeRgn ; now create the Structure Region by doing a FrameRRect on the strucRect. _OpenRgn PushLong #strucRect ldy #xowRH ; these are the radii of the corners PushWord [<theWindow],y ldy #xowRV PushWord [<theWindow],y _FrameRRect ldy #owStrucRgn+2 ; push on the handle of the structure lda [<theWindow],y ; region stored in the window record. sta StrucRgnHandle+2 pha dey dey lda [<theWindow],y sta StrucRgnHandle pha _CloseRgn clc rts ContRgnHandle ds 4 StrucRgnHandle ds 4 TempRgn ds 4 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; Fetches the portrect from the window record, and converts it to ; global coordinates. It leaves the rectangle in 'pRect' and 'contRect' ; ; LocalToGlobal conversion is done by subtracting boundsRect.y1 from the ; vertical coordinates of portRect, and doing similarly for the horizontal ; coordinates. This is essentially saying "How far away from the top and ; left edges of the screen is the portRect?". ; GetpRect ldy #oport+oboundsRect lda [<theWindow],y ;Get the boundsRect y1,x1 and save it in a way sta atoglobal ;that allows us to use it conveniently. sta atoglobal+4 iny iny lda [<theWindow],y sta atoglobal+2 sta atoglobal+6 ldy #oport+oportRect+6 ldx #6 ;Globalize the portRect and save it where aa lda [<theWindow],y ;"others" can get it. sec sbc atoglobal,x sta pRect,x sta contRect,x dey dey dex dex bpl aa rts atoglobal ds 8 end EJECT ******************************************************************************* * rrNew start * * Description: * * Perform any window record initialization. This routine is should set : * * - the wRefCon, wContDraw, wColors, and wFrameCtls fields. * - the fCtlTie, fVis, and fQContent bits in wFrame word. * - any other fields in the Custom part of the record. * * The following has already been done: * * - a window record has been allocated (as specified by the wNew call). * - a port has been opened (as specified by the wPosition call). * - handles have been placed in wStrucRgn, wContRgn, and wUpdateRgn. * - wContDefProc points to us. * - the window has been added to the window list, and wNext field set. * - the fAllocated and fHilited bits have been set. All others are zero. * * Here is the window record. Asterisks are by the fields we have to set up: * * -4 owNext * 0 owPort * 170 owDefProc * *174 owrRefCon * *178 owContDraw * 182 owReserved * 186 owStrucRgn * 190 owContRgn * 194 owUpdateRgn * 198 owCtls * *202 owFrameCtls * *206 owFrame * *208 owCustom * * * Inputs: param = pointer to parameter list supplied to _NewWindow * * Outputs: result = zero * carry = clear * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData ; ; Set the frame bits based on the _NewWindow parmlist settings. ; ; We only really pay attention to: fClose, fMove. ; ; In addition, Window manager requires: fVis, fQContent, fCtlTie. ; ldy #wFrameBits ; Get the bits from the parm list. lda [<param],y ; Make sure we don't affect fAllocated and #$FFFF-fAllocated-fHilited ; or fHilited. ldy #owFrame ; Get the bits as the WM has them. ora [<theWindow],y ; Merge his and ours together... sta [<theWindow],y ; ...and save them. ; copy the wRefCon, wContDraw, and wColors from the parmlist ldy #owrRefCon ; dest index ldx #wRefCon ; source index lda #8 ; bytes to move jsr CopyBlock ; Copy all of the custom stuff into the end of the window record ldy #windSize ; used as dest index ldx #wCustom ; used as source index lda #wEnd-wCustom ; bytes to move jsr CopyBlock ; The frame controls are already zeroed out by the Window manager before ; we get called, so we don't have to initialize that field. ; Finally, calculate the Frame and Content regions jsr rrCalcRgns clc rts CopyBlock ANOP sta Count loop ANOP phy ; save the dest index txy ; transfer in the source index lda [<param],y ; get a source word ply ; retrieve the dest index sta [<theWindow],y ; save the copy iny ; bump our indices iny inx inx dec Count ; are we done? dec Count bne loop ; no - copy some more rts Count ds 2 end EJECT ******************************************************************************* * rrDispose start * * Description: Dispose of any additional fields created by the wNew call, * and tell the Window manager whether or not it should * continue the disposal. If we return FALSE, the Window * Manager will: * * - erase the window from the screen * - remove the window from the window list * - free any controls in wControls and wFrameCtls * - free the strucRgn, contRgn, and updateRgn handles * - close the GrafPort * - release the window record if it was allocated * dynamically (see allocate bit in wFrame field) * * * Inputs: NONE * * Outputs: to continue disposal: result = FALSE (zero) * to abort disposal: result = TRUE (non-zero) * in either case... carry = clear * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData clc rts end EJECT ******************************************************************************* * rrGetDrag start * * Description: Return the address of the routine that will draw the * outline of the window as it is dragged. You can take the * easy way out and return $0000 0000 in 'result'; that will * tell the window manager take care of matters by dragging * the bounds rectangle of the strucRgn. I use my own routine * which draws a RoundRect. * * * Inputs: NONE * * Outputs: result = pointer to Drag routine, $0000 0000 for default * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData lda #myDrag ; return the pointer to my routine sta <result lda #^myDrag sta <result+2 jsr GetStrucRect ; get a copy of the rect to drag lda strucRect ; make a local copy sta DragRect lda strucRect+2 sta DragRect+2 lda strucRect+4 sta DragRect+4 lda strucRect+6 sta DragRect+6 ldy #xowRV ; get the radii of the corners lda [<theWindow],y sta localRV ldy #xowRH lda [<theWindow],y sta localRH clc rts ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; This drag routine will be called with the following parameters: ; ; PUSH:WORD - delta X (signed) ; PUSH:WORD - delta Y (Your truly,) ; PUSH:BYTE[3] - return address RTLAddr equ 1 DY equ RTLAddr+3 DX equ DY+2 myDrag ANOP clc ; offset/copy the original rectangle lda DragRect adc DY,s sta DragRect2 clc lda DragRect+2 adc DX,s sta DragRect2+2 clc lda DragRect+4 adc DY,s sta DragRect2+4 clc lda DragRect+6 adc DX,s sta DragRect2+6 pha ; save the pen mode _GetPenMode PushWord #modeXOR ; and change it to XOR _SetPenMode PushLong #DragRect2 PushWord localRH PushWord localRV _FrameRRect _SetPenMode ; restore the old pen mode lda RTLAddr,s ; move the rtl address back up sta 5,s lda RTLAddr+1,s sta 6,s pla ; remove the parameters pla rtl ; back to dragrect! DragRect ds 8 DragRect2 ds 8 localRH ds 2 localRV ds 2 end EJECT ******************************************************************************* * rrGrowFrame start * * Description: Draw the outline of the window frame as it is grown. The * easiest way to deal with this routine is to ignore * everything passed to it, and return $0000 in result. This * will grow windows the normal way. * * * Inputs: 'param' points to the following data structure: * * newsize RECT Rectangle that defines the new size * drawFlag WORD TRUE to draw frame, false to erase * startRect RECT Bounds of wStrucRgn when dragging started. * deltaY WORD Vertical movement since starting to drag (signed). * deltaX WORD Horizontal movement since starting to drag (signed). * * Outputs: 'result' should have the following bits set or clear: * * 0: TRUE if frame was drawn by us, FALSE if default frame is requested. * 1: TRUE if newSize RECT was changed in a custom fashion, FALSE if not. * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData newSize equ 0 drawFlag equ newSize+8 startRect equ drawFlag+2 deltaY equ startRect+8 deltaX equ deltaY+2 ; ; param is a pointer to a data block, the first 8 bytes of which ; is the rectangle we want to draw. So push Param on the stack for ; FrameRRect. ; PushLong <param ldy #xowRH PushWord [<theWindow],y ldy #xowRV PushWord [<theWindow],y _FrameRRect lda #%0001 ; say the we drew the rect but sta <result ; didn't change it. clc rts end EJECT ******************************************************************************* * rrRecSize start * * Description: Return the size of the window record required by this * defProc. This number is the number of bytes needed beyond * the number normally allocated by the window manager. * * If you want to indicate that storage has already been * allocated (perhaps a a field was set in the NewWindow * parameter list, like wStorage in the standard window list), * then return the pointer to that record with bit 31 set. * * * Inputs: param = pointer to parameter list supplied to _NewWindow * * Outputs: result = number of additional bytes required, or * pointer to window record with the high bit set * carry = clear * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData ; Let's see if there is storage defined in the parameter list ldy #wStorage lda [<param],y iny iny ora [<param],y bne Allocated ; No, so tell the window manager how large it should be lda #xowEnd-windSize sta <result bra done Allocated ANOP lda [<param],y ; Return the high word with the high ora #$8000 ; bit set to tell the WMgr what we did. sta <result+2 dey dey lda [<param],y ; Return the low word normally sta <result done ANOP clc rts end EJECT ******************************************************************************* * rrPosition start * * Description: Supply the rectangle to be used as the window's PortRect. * * * Inputs: param = pointer to parameter list supplied to _NewWindow * * Outputs: result = pointer to the rect to be used as the PortRect * carry = clear * * External Refs: * * Entry Points: * ******************************************************************************* using RRectDefProcData ; Take the pointer to the parameter list and add the offset to field ; that holds the portrect. ADD4 #wPosition,<param,<result clc rts end EJECT ******************************************************************************* * rrBehind start * * Description: This routine extracts the wPlane value of the parmList * passed to NewWindow and passes it back to the Window * Manager in 'result'. Pass back $FFFF FFFF to always place * the window on top, or $0000 0000 to place the window on the * bottom. * * * Inputs: param = pointer to parameter list passed to _NewWindow * * Outputs: result = window pointer, $FFFF FFFF, or $0000 0000 * carry = clear * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData ldy #wPlane ; simply get what was specified in lda [<param],y ; the parameter list supplied to sta <result ; _NewWindow (since we are the only iny ; one who knows where is it) and return iny ; it to the Window Manager. lda [<param],y sta <result+2 clc rts end EJECT ******************************************************************************* * rrCallDefProc start * * Description: Generic call to the defProc. Through this, the Window * Manager can access the fields in the custom window's * data in response to the many Get/Set calls. * * * Inputs: On entry, 'param' points to the following block of data: * * WORD : dRequest Requested operation number * WORD : paramID Parameter block type: * $0000-7FFF reserved by system * $8000-FFFF reserved for application * (We only handle type $0000 System * in this sample) * XXXX : newParam Operation specific data * * Outputs: Call specific. See technote for more details. * * External Refs: * Import rrSetTitle * Import rrSetColor * Import rrSetFrame * Import rrGetTitle * Import rrGetColor * Import rrGetFrame * Import handleWTask * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData dRequest equ 0 paramID equ dRequest+2 newParam equ paramID+2 MaxDRequest equ 33 ldy #paramID ; Do we know this paramID type? lda [<param],y bne ignore ; $0000, ignore all others lda [<param] ; dRequest cmp #MaxDRequest+1 ; is this request in range? bcs ignore ; no so leave asl a ; yes, turn into index into proc table tax jmp (dRequestTable,x) dRequestTable ANOP dc i2'ignore' ; 0 wSetOrgmask dc i2'ignore' ; 1 wSetMaxGrow dc i2'ignore' ; 2 wSetScroll dc i2'ignore' ; 3 wSetPage dc i2'ignore' ; 4 wSetInfoRefCon dc i2'ignore' ; 5 wSetInfoDraw dc i2'ignore' ; 6 wSetOrigin dc i2'ignore' ; 7 wSetDataSize dc i2'ignore' ; 8 wSetZoomRect dc i2'rrSetTitle' ; 9 wSetTitle dc i2'rrSetColor' ; 10 wSetColorTable dc i2'rrSetFrame' ; 11 wSetFrameFlag dc i2'ignore' ; 12 wGetOrgMask dc i2'ignore' ; 13 wGetMaxGrow dc i2'ignore' ; 14 wGetScroll dc i2'ignore' ; 15 wGetPage dc i2'ignore' ; 16 wGetInfoRefCon dc i2'ignore' ; 17 wGetInfoDraw dc i2'ignore' ; 18 wGetOrigin dc i2'ignore' ; 19 wGetDataSize dc i2'ignore' ; 20 wGetZoomRect dc i2'rrGetTitle' ; 21 wGetTitle dc i2'rrGetColor' ; 22 wGetColorTable dc i2'rrGetFrame' ; 23 wGetFrameFlag dc i2'ignore' ; 24 wGetInfoRect dc i2'ignore' ; 25 wGetDrawInfo dc i2'ignore' ; 26 wGetStartInfoDraw dc i2'ignore' ; 27 wGetEndInfoDraw dc i2'ignore' ; 28 wZoomWindow dc i2'ignore' ; 29 wStartDrawing dc i2'rrStartMove' ; 30 wStartMove (defined in this PROC) dc i2'ignore' ; 31 wStartGrow dc i2'rrNewSize' ; 32 wNewSize (defined in this PROC) dc i2'handleWTask' ; 33 wTask rrStartMove ldy #newParam+2 ; Preparing to move the window. Examine lda [<param],y ; the proposed destination rectangle sta <result+2 ; and see if it is OK. If it is, simply dey ; return it. If it isn't, then change dey ; it. We will like it, so we'll just lda [<param],y ; return what we get. sta <result clc rts rrNewSize ANOP lda #1 ; Always return TRUE. This tells the sta <result ; window manager to redraw only clc ; uncovered contents. rts ignore clc rts end EJECT ******************************************************************************* * handleWTask start * * Description: Called to handle FindWindow results passed on by * TaskMaster. Since TaskMaster only handles event that occur * in menus and system windows, custom window defprocs must * handle all of the rest. These include: * * wInContent wInDrag * wInGrow wInGoAway * wInZoom wInInfo * wInFrame * * * Inputs: 'param' points to the following block of data: * * WORD:dRequest = 33 for wTask * WORD:paramID we only handle type $0000 System calls * LONG:newParam Pointer to Task Record * WORD:newParam result from FindWindow * * Outputs: 'result' equals the following: * * Low Word High Word * ----------------- ------------------- * If the event was handled: Zero Action taken * If the event was not handled: FindWindow result ignored * * External Refs: NONE * * Entry Points: NONE * ******************************************************************************* using RRectDefProcData dRequest equ 0 paramID equ dRequest+2 newParam equ paramID+2 TaskRecPtr equ newParam FWResult equ TaskRecPtr+4 TaskRec equ work ldy #TaskRecPtr+2 ; get the pointer to the Event Record lda [<param],y ; into 'TaskRec', aka 'work'. sta <TaskRec+2 dey dey lda [<param],y sta <TaskRec ldy #FWResult ; get the Findwindow result lda [<param],y sec ; turn it into an index sbc #wInContent bcc callIgnore ; out of range, so ignore cmp #wInFrame-wInContent+1 bcc doit callIgnore lda #wInSpecial-wInContent+1 doit asl a tax jmp (wTaskTable,x) wTaskTable dc i2'doInContent' ; doInContent dc i2'doInDrag' ; doInDrag dc i2'ignoreTask' ; doInGrow dc i2'doInGoAway' ; doInGoAway dc i2'ignoreTask' ; doInZoom dc i2'ignoreTask' ; doInInfo dc i2'ignoreTask' ; doInSpecial (default ignore) dc i2'ignoreTask' ; doInDeskItem (not used) dc i2'doInContent' ; doInFrame ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; TaskMaster needs us to handle a wInContent event. Check the TaskMask ; field to see if the application wants us to handle it. If so, bring the ; window to front. Then check to see if the application wants to know what ; we just did. If so, return wInContent. If not, return null. doInContent ANOP ldy #owmTaskMask ; do we handle clicks in the content? lda [<TaskRec],y and #tmContent bne Bogus0010 ; yes - just select the window brl ignoreTask ; no - so pretend we weren't here. Bogus0010 jsr mySelectWindow ldy #owFrame ; do we tell the app what we did? lda [<theWindow],y and #fQContent beq Passively ; no - just return a nullEvt ldx #0 lda #wInContent ; pass this on to the application brl Exit Passively ANOP ldx #wInContent ; This is what we did. lda #0 ; Signal that event was handled brl Exit ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; TaskMaster needs us to handle a wInDrag event. Check the TaskMask ; field to see if the application wants us to handle it. If so, call ; DragWindow with the same parameters described in the TaskMaster ; psuedo-code in the ToolBox Reference. Then check to see if the Apple ; key was down. If it wasn't, bring the window forward. Finally, return ; null. ; doInDrag ANOP ldy #owmTaskMask ; do we do drags? lda [<TaskRec],y and #tmDragW bne Bogus0020 ; yes - get on with it. brl ignoreTask ; no - so pretend we weren't here. Bogus0020 ANOP PushWord #0 ; drag resolution ldy #owhere+2 ; global coord of cursor PushWord [<TaskRec],y ; first X dey dey PushWord [<TaskRec],y ; then Y PushWord #8 ; grace buffer around bounds PushLong #0 ; default cursor boundary ldy #owmTaskData+2 ; push on window's grafport PushWord [<TaskRec],y dey dey PushWord [<TaskRec],y _DragWindow ; Call DrawWindow ourselves ldy #omodifiers ; if the Apple Key is down then lda [<TaskRec],y ; don't bring the window to front and #appleKey bne doneDrag jsr mySelectWindow doneDrag ANOP ldx #wInDrag ; This is what we did. lda #0 ; Signal that event was handled bra Exit ; Exit the DefProc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; TaskMaster needs us to handle a wInGoAway event. Check the TaskMask ; field to see if the application wants us to handle it. If so, call ; TrackGoAway. If it returns TRUE, then return wInGoAway to the ; application. If it returns FALSE, return wNoHit. ; doInGoAway ANOP pha ; space for boolean result ldy #owhere+2 ; global coord of cursor PushWord [<TaskRec],y ; first X dey dey PushWord [<TaskRec],y ; then Y ldy #owmTaskData+2 ; push on window's grafport PushWord [<TaskRec],y dey dey PushWord [<TaskRec],y _TrackGoAway pla beq noClose ldx #0 ; Close selected. Tell app that we lda #wInGoAway ; clicked in the goAway box. bra Exit noClose ANOP ldx #wInGoAway ; Close not selected. Tell the app that lda #wNoHit ; we tracked it, but that everything is bra Exit ; OK now. ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; Local routine to bring the window forward if we need to. ; mySelectWindow ANOP lda <theWindow ; get the pointer to the window so that clc ; we can bring it to front. adc #4 tax lda <theWindow+2 pha phx _SelectWindow rts ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; For some reason, we need to ignore a task. Either we were asked to handle ; an event we know nothing about, or the TaskMask prohibited us from ; handling a certain event. This routine simply echos the result found by ; FindWindow back to the application. ignoreTask ldy #FWResult ; ignore by echoing the FindWindow lda [<param],y ; result. ldx #0 ; fall through to Exit. Exit ANOP sta <result ; TaskMaster result on the stack stx <result+2 ; Low word of TaskData clc rts end EJECT ******************************************************************************* * HouseKeeping start * * Description: Housekeeping calls. Set and get various fields. These will * redraw the window if necessary. * * * Inputs: * * Outputs: * * External Refs: * Import drawFrame * * Entry Points: * entry rrSetTitle * entry rrSetColor * entry rrSetFrame * entry rrGetTitle * entry rrGetColor * entry rrGetFrame * ******************************************************************************* using RRectDefProcData dRequest equ 0 paramID equ dRequest+2 newParam equ paramID+2 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrSetTitle entry ldy #xowTitle+2 bra SetLong ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrSetColor entry ldy #xowColorPtr+2 bra SetLong ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrSetFrame entry ldy #owFrame bra SetWord ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrGetTitle entry ldy #xowTitle+2 bra GetLong ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrGetColor entry ldy #xowColorPtr+2 bra GetLong ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; rrGetFrame entry ldy #xowColorPtr bra GetWord ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; SetLong ANOP phy ldy #newParam+2 lda [<param],y ply sta [<theWindow],y dey dey SetWord phy lda #newParam lda [<param],y ply sta [<theWindow],y lda <theWindow ; Now redraw the window frame clc adc #4 tax lda <theWindow+2 pha phx _StartFrameDrawing ; must be called by defproc jsr drawFrame _EndFrameDrawing ; reverses StartFrameDrawing call clc rts ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; ; ; Called by the rrGetxxxxx routines above. Enter with Y holding the ; offset to a LONG parameter in the window record. This routine will ; fetch that value and put it into 'result'. ; GetLong ANOP lda [<theWindow],y sta <result+2 dey dey GetWord lda [<theWindow],y sta <result clc rts end